package student.aistar.day15.syn;

public class SynHello extends Thread{
    @Override
    public void run() {
        add();
        test();
    }

    //修饰一个静态方法
    //在同一时刻, 只能有一个线程进入同步代码块中去执行
    //类锁 - 作用于这个类下的所有对象
    //      这个类实例化出来的所有的对象竞争得都是同一把锁 - 类锁

    /**
     * Thread t1 = new SynHello();
     * Thread t2 = new SynHello();
     * 我们构建了SynHello类得两个对象t1, t2 -> 竞争的锁是同一把锁
     * 谁抢到锁资源, 谁就会进入到同步代码块中去执行, 没有抢到锁资源得线程进入到同步阻塞状态
     * 等到cpu在空闲的时候去再次调用
     *
     * t1若抢到锁, 并且成功执行, 执行结束之后, 那么t1对象会释放锁
     * 后台还有t2线程, 锁就会被t2强盗, 进去执行, 执行完毕之后, 仍然会释放锁
     */
    private static synchronized void add() {//申请的是"类锁"
        System.out.println(Thread.currentThread().getName() + "0");
        //此处睡得一个目的就是为了 ...得瑟一下

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //睡完之后, 两个线程再次被cpu进行调度
        System.out.println(Thread.currentThread().getName() + "1");
    }

    /**
     * Thread t1 = new SynHello();
     * Thread t2 = new SynHello();
     *
     * t1 - 竞争锁资源A
     * t2 - 竞争锁资源B
     *
     * 如果t1 - 竞争自己的锁A, 并不会影响t2去竞争他自己得锁资源B
     */
    private synchronized void test() {//申请的对象锁 - 每个对象都拥有一把自己得锁
        System.out.println(Thread.currentThread().getName() + "0");
        //此处睡得一个目的就是为了 ...得瑟一下

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //睡完之后, 两个线程再次被cpu进行调度
        System.out.println(Thread.currentThread().getName() + "1");
    }
}

class TestSynHello{
    public static void main(String[] args) {
        Thread t1 = new SynHello();
        Thread t2 = new SynHello();

        t1.setName("线程one");
        t2.setName("线程two");

        //启动线程 - start
        t1.start();
        t2.start();
    }
}
